'use strict';

const fs = require('fs');
const path = require('path');
/**
 * 服务基类
 */
class BaseService {
  /**
   * 构造函数
   * @param {string} name 服务名称
   */
  constructor(name) {
    this.name = name;
    this.methods = {};
    this.properties = {};
    // 读取baseConfig.json判断是否为调试模式
    this.isDebug = this._loadIsDebugSetting();
  }
  /**
   * 从baseConfig.json加载isDebug配置
   * @returns {boolean} 是否为调试模式
   * @private
   */
  _loadIsDebugSetting() {
    try {
      const baseConfigPath = path.resolve(process.cwd(), 'config/baseConfig.json');
      if (fs.existsSync(baseConfigPath)) {
        const configContent = fs.readFileSync(baseConfigPath, 'utf8');
        const config = JSON.parse(configContent);
        return config.isDebug === true;
      }
    } catch (error) {
      console.error('[Logger] 加载baseConfig.json失败，默认为开发环境:', error);
    }

    // 默认为true，保留原有行为
    return process.env.NODE_ENV !== 'production';
  }
  /**
   * 注册方法
   * @param {string} methodName 方法名称
   * @param {Function} method 方法实现
   * @param {object} options 方法选项 (needReturn, returnType)
   */
  registerMethod(methodName, method, options = {}) {
    if (typeof method !== 'function') {
      throw new Error(`注册方法 ${methodName} 失败：必须是函数`);
    }

    // 存储方法实现和返回值配置
    this.methods[methodName] = {
      implementation: method.bind(this),
      needReturn: options.needReturn || false,
      returnType: options.returnType || null
    };
  }

  /**
   * 注册属性
   * @param {string} propertyName 属性名称
   * @param {any} getter 获取属性的函数或值
   * @param {Function} setter 设置属性的函数（可选）
   */
  registerProperty(propertyName, getter, setter = null) {
    this.properties[propertyName] = {
      get: typeof getter === 'function' ? getter.bind(this) : () => getter,
      set: setter ? setter.bind(this) : null
    };
  }

  /**
   * 调用方法
   * @param {string} methodName 方法名称
   * @param {Array} args 参数数组
   * @returns {Promise<any>} 方法执行结果
   */
  async invoke(methodName, args = []) {
    const methodObj = this.methods[methodName];
    if (!methodObj || !methodObj.implementation) {
      throw new Error(`方法 ${methodName} 不存在`);
    }

    try {
      // 执行方法
      const result = await methodObj.implementation(...args);

      // 检查是否需要返回结果
      if (methodObj.needReturn) {
        return result; // 需要返回结果
      }

      // 不需要返回结果，返回成功状态
      return { success: true };
    } catch (error) {
      console.error(`[${this.name}] 调用方法 ${methodName} 失败:`, error);
      throw error;
    }
  }

  /**
   * 获取属性值
   * @param {string} propertyName 属性名称
   * @returns {Promise<any>} 属性值
   */
  async getProperty(propertyName) {
    const property = this.properties[propertyName];
    if (!property || !property.get) {
      throw new Error(`属性 ${propertyName} 不存在或不可读`);
    }

    try {
      return await property.get();
    } catch (error) {
      console.error(`[${this.name}] 获取属性 ${propertyName} 失败:`, error);
      throw error;
    }
  }

  /**
   * 设置属性值
   * @param {string} propertyName 属性名称
   * @param {any} value 属性值
   * @returns {Promise<void>}
   */
  async setProperty(propertyName, value) {
    const property = this.properties[propertyName];
    if (!property || !property.set) {
      throw new Error(`属性 ${propertyName} 不存在或不可写`);
    }

    try {
      await property.set(value);
    } catch (error) {
      console.error(`[${this.name}] 设置属性 ${propertyName} 失败:`, error);
      throw error;
    }
  }
  /**
   * 停止服务
   */
  async stop() {
    console.log(`[${this.name}] 服务已停止`);
  }
}

module.exports = BaseService; 